home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / agrep / asearch1.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  5KB  |  132 lines
  1. /* Copyright (c) 1991 Sun Wu and Udi Manber.  All Rights Reserved. */
  2. #include "agrep.h"
  3.  
  4. extern unsigned Init1, Init[], Mask[], endposition, D_endpos;
  5. extern unsigned NO_ERR_MASK;
  6. extern int TRUNCATE, DELIMITER, AND, I, S, DD, INVERSE, FILENAMEONLY ;
  7. extern char CurrentFileName[];
  8. extern int num_of_matched;
  9.  
  10.  
  11. asearch1(old_D_pat, Text, D)
  12. char old_D_pat[]; int Text; register unsigned D;
  13. {
  14.   register unsigned end, i, r1, r2, r3, r4, r5, CMask, D_Mask, Init0, k, endpos; 
  15.   register unsigned r_NO_ERR;
  16.   unsigned A[MaxError*2+1], B[MaxError*2+1];
  17.   int D_length, ResidueSize, lasti, num_read,  FIRSTROUND, j=0;
  18.   char buffer[BlockSize+Max_record+1];
  19.    
  20.   if(I == 0) Init1 = 037777777777;
  21.   if(DD > D) DD = D+1;
  22.   if(I  > D) I  = D+1;
  23.   if(S  > D) S  = D+1;
  24.   D_length = strlen(old_D_pat);
  25.   buffer[Max_record-1] = '\n';
  26.    
  27.   lasti = Max_record;
  28.   r_NO_ERR = NO_ERR_MASK;
  29.  
  30.   D_Mask = D_endpos;
  31.   for(i=1 ; i<D_length; i++) D_Mask = (D_Mask << 1) | D_Mask;
  32.   D_Mask = ~D_Mask;
  33.   endpos = D_endpos;
  34.   r3 = D+1; r4 = D*2;  /* to make sure in register */
  35.   for(k=0; k < D;   k++) A[k] = B[k] = 0;
  36.   for(k=D; k <= r4; k++) A[k] = B[k] = Init[0];
  37.    
  38.   while ((num_read = fill_buf(Text, buffer + Max_record, Max_record)) > 0)
  39.   {
  40.     i=Max_record; end = Max_record + num_read;
  41.     if(FIRSTROUND) { i = Max_record -1 ;
  42.             if(DELIMITER) {
  43.                 for(k=0; k<D_length; k++) {
  44.                     if(old_D_pat[k] != buffer[Max_record+k])                         break;
  45.                 }
  46.                 if(k>=D_length) j--;
  47.             }
  48.                      FIRSTROUND = 0; }
  49.     if(num_read < BlockSize) {
  50.                       strncpy(buffer+Max_record+num_read, old_D_pat, D_length);
  51.                       end = end + D_length;
  52.                       buffer[end] = '\0';
  53.     }
  54.     while (i < end)
  55.     {
  56.         CMask = Mask[buffer[i++]];
  57.               r1 = Init1 & B[D];
  58.               A[D] = ((B[D] >> 1) & CMask )  | r1;
  59.               for(k = r3; k <= r4; k++)  /* r3 = D+1, r4 = 2*D */
  60.               { 
  61.                   r5 = B[k];
  62.                   r1 = Init1 & r5;
  63.                   A[k] = ((r5 >> 1) & CMask) | B[k-I] |                                                (((A[k-DD] | B[k-S]) >>1) & r_NO_ERR) | r1 ; 
  64.               }
  65.         if(A[D] & endpos) {  
  66.            j++;
  67.            if(((AND == 1) && ((A[D*2] & endposition) == endposition)) ||                           ((AND == 0) && (A[D*2] & endposition)) ^ INVERSE )
  68.                    { 
  69.                      if(FILENAMEONLY) {
  70.             num_of_matched++;
  71.                         printf("%s\n", CurrentFileName);
  72.                         return;       } 
  73.                      if(lasti < Max_record + num_read)
  74.                         output(buffer, lasti, i-D_length-1, j); 
  75.                    }
  76.            lasti = i - D_length;
  77.            TRUNCATE = OFF;
  78.            for(k = D; k <= r4 ; k++) A[k] = B[k] = Init[0];
  79.            r1 = Init1 & B[D];
  80.            A[D] = (((B[D] >> 1) & CMask )  | r1) & D_Mask;
  81.            for(k = r3; k <= r4; k++)  /* r3 = D+1, r4 = 2*D */
  82.               { 
  83.                   r5 = B[k];
  84.                   r1 = Init1 & r5;
  85.                   A[k] = ((r5 >> 1) & CMask) | B[k-I] |                                                (((A[k-DD] | B[k-S]) >>1) & r_NO_ERR) | r1 ; 
  86.               }
  87.         }  /* end if (A[D]&endpos) */
  88.         CMask = Mask[buffer[i++]];
  89.               r1 = A[D] & Init1;
  90.               B[D] = ((A[D] >> 1) & CMask) | r1;
  91.               for(k = r3; k <= r4; k++)
  92.               { 
  93.                   r1 = A[k] & Init1;
  94.                   B[k] = ((A[k] >> 1) & CMask) | A[k-I] |                                                (((B[k-DD] | A[k-S]) >>1)&r_NO_ERR) | r1 ; 
  95.               }
  96.         if(B[D] & endpos)  {  
  97.              j++;
  98.            if(((AND == 1) && ((B[r4] & endposition) == endposition)) ||                           ((AND == 0) && (B[r4] & endposition)) ^ INVERSE )
  99.                    { if(FILENAMEONLY) {
  100.                         num_of_matched++;
  101.                         printf("%s\n", CurrentFileName);
  102.                         return;       }
  103.                      if(lasti < Max_record + num_read)
  104.                         output(buffer, lasti, i-D_length-1, j); 
  105.                    } 
  106.            lasti = i-D_length; 
  107.            TRUNCATE = OFF;
  108.            for(k=D; k <= r4; k++) A[k] = B[k] = Init[0];
  109.            r1 = Init1 & A[D];
  110.            B[D] = (((A[D] >> 1) & CMask )  | r1) & D_Mask;
  111.            for(k = r3; k <= r4; k++)  /* r3 = D+1, r4 = 2*D */
  112.               { 
  113.                   r5 = A[k];
  114.                   r1 = Init1 & r5;
  115.                   B[k] = ((r5 >> 1) & CMask) | A[k-I] |                                                (((B[k-DD] | A[k-S]) >>1) & r_NO_ERR) | r1 ; 
  116.               }
  117.         }  /* end if (B[D]&endpos) */
  118.     }
  119.     ResidueSize = Max_record + num_read - lasti;
  120.     if(ResidueSize > Max_record) {
  121.             ResidueSize = Max_record;
  122.             TRUNCATE = ON;   
  123.     }
  124.     strncpy(buffer+Max_record-ResidueSize, buffer+lasti, ResidueSize);
  125.     lasti = Max_record - ResidueSize;
  126.     if(lasti < 0) lasti = 1;
  127.     if(num_read < BlockSize) lasti = Max_record;
  128.   }
  129.   return;
  130. }
  131.  
  132.